home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / pmode / qfml11 / example2.cpp < prev    next >
C/C++ Source or Header  |  1995-03-06  |  5KB  |  178 lines
  1. /*********************************************************************
  2. ** QFML DEMO :
  3. **   ALTHOUGH THIS LISTING CAN'T BE MODIFIED, IT SHOWS HOW QFM WORKS.
  4. **     IT LOADS TWO 320x200x256 IMAGES INTO THE MEMORY ALLOCATED BY
  5. **   OPENMEM AND MOVES A WINDOW IN THEM WICH CAN BE SEEN ON THE
  6. **   SCREEN.
  7. **     TO SEE A DEATILED EXPLANATION OF QFM'S FUNCTIONS READ DE READ-
  8. **   ME FILE AND THE QFML.H FILE.
  9. **
  10. **   THE PAN IMAGE FORMAT IS JUST A QUICK RAW FORMAT.
  11. **   THE VIDEO.H AND VIDEO.C HAVE NOT BEEN INCLUDED IN THIS PACKAGE
  12. ** BUT THEY ARE NOT REALLY  IMPORTANT AS IT IS JUST A SIMPLE DRIVER
  13. ** FOR MCGA MODE.
  14. **
  15. ** (C) RENDER OF ACC TEAM (1995)
  16. *********************************************************************/
  17.  
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <conio.h>
  21. #include "video.h"
  22. #include "qfml.h"                // To use QFML functions include this file
  23.                                  // and link with qfml.obj
  24.  
  25. #define word unsigned int
  26. #define dword unsigned long int
  27. #define byte unsigned char
  28. #define NUM 2
  29.  
  30. //-------------------------------------------------
  31. // Just a function to load the palette to use
  32.  
  33. void
  34. LoadMCGAPalette3(char *nombre,byte *colores,char extendido)
  35. {
  36.     FILE    *f;
  37.     int    b,c,a;
  38.  
  39.     f=fopen(nombre,"rb");
  40.     if (!ferror(f)){
  41.         if (extendido)
  42.                 colores[0]=getc(f);
  43.         a=0;
  44.         do{
  45.             colores[a]=getc(f);
  46.             a=a+1;
  47.         }while ( (!feof(f)) && (a<768) );
  48.         b=FP_SEG(colores);
  49.         c=FP_OFF(colores);
  50.         asm{
  51.                 mov    ah,0x10
  52.                 mov     al,0x12
  53.                 mov    bx,0
  54.                 mov    cx,256
  55.                 mov    dx,c
  56.                 mov     es,b
  57.  
  58.                 int    0x10
  59.         }
  60.         fclose(f);
  61.   }else printf("\  Error: File error.\n");
  62. }
  63.  
  64. //----------------------------------------------------
  65. // Just a function to rotate the palette (very simple)
  66.  
  67. void
  68. CicloPal(byte *colores)
  69. {
  70.     word b,c;
  71.  
  72.     for (int a=3;a<768;a++)
  73.         colores[a]++;
  74.  
  75.  
  76.     b=FP_SEG(colores);
  77.     c=FP_OFF(colores);
  78.     asm{
  79.             mov    ah,0x10
  80.             mov     al,0x12
  81.             mov    bx,0
  82.             mov    cx,256
  83.             mov    dx,c
  84.             mov     es,b
  85.  
  86.             int    0x10
  87.     }
  88. }
  89.  
  90. //============================================================
  91. // Look carefully at this one, this is the IMPORTANT BIT.
  92.  
  93. void
  94. main(void)
  95. {
  96.     dword First_addr;                 // Keeps starting QFM's memory address
  97.     dword MCGA_off;                   // Plane address of video mem.
  98.     dword num_ks;                     // Keeps the amount of K's reserved
  99.     dword p5;                         // Auxiliar
  100.  
  101.     dword a;                          // Used as an offset to First_addr
  102.     byte pal[768];                    // For the palette to rotate
  103.  
  104.     char *cads[]={                    // File names
  105.         "screen01.pan",
  106.      "screen02.pan",
  107.     };
  108.  
  109.  
  110.     // First of all start QFM before leaving textmode
  111.     if (StartPL()) exit(1);
  112.  
  113.     // Then open the whole mem after the first Megabyte.
  114.     if (OpenMem()) {
  115.       LeavePL();           // Leave QFM mode before leaving your code.(ALWAYS)
  116.       exit(1);
  117.     }
  118.  
  119.     // We get the amount of memory available
  120.     num_ks=GiveAmo();
  121.     if (num_ks<130) {      // We need a minimum of 128 k
  122.       CloseMem();          // Close mem. before leavinf QFM. (ALWAYS)
  123.       LeavePL();           // Leave QFM mode before leaving your code.(ALWAYS)
  124.     }
  125.     printf ("Available memory after first Mgb. (Kbytes):%lu\n",num_ks);
  126.  
  127.     // Then we need the starting address of this block in plane
  128.     // memory. Observe it will always be after position 1048576 (1Mb)
  129.     First_addr=GiveSta();
  130.     printf ("First Address:%lu\n",First_addr);
  131.  
  132.     // Wait just a little before leaving text mode
  133.     delay(50*50);
  134.     PutVideo(0x13);        // This is a <video.h> function. It starts 13h mode
  135.  
  136.     // We need the starting address of video ram. As a example I use the
  137.     // VirToPL function to translate a seg:off mode to a 4Gb offset
  138.     MCGA_off=VirToPL(0xa000,0);       //MCGA_off MCGA
  139.  
  140.     // Then we load the two screens, one after the other.
  141.     // Observe that in 320x200x256 mode the screen is just
  142.     // an array of 64000 bytes containg each the color register of that
  143.     // pixel. For Example color of pixel x=29,y=30 is just offset
  144.     // y*320+x in the segment A000h
  145.     for(a=0;a<NUM;a++){
  146.       LoadMCGAScreen(cads[a],1);      // This is a <video.h> function.It loads
  147.                                       // a PAN and puts it into video memory.
  148.       p5=First_addr+64000L*a;         // We calculate the 4Gb offset were we
  149.       Pl2Pl(MCGA_off,p5,64000L);      // will copy the 64000 array to
  150.     }
  151.  
  152.     LoadMCGAPalette3(cads[0],pal,1);  // Just Load a palette
  153.  
  154.     ClearVideo();                     // Clear the screen
  155.  
  156.     // repeat this bucle until a key is hit
  157.     for (;!kbhit();){
  158.  
  159.         for (a=0;( (a<(NUM-1)*64000)&&(!kbhit()) );a+=320){
  160.             Pl2Pl(First_addr+a,MCGA_off,64000L);    // Show a part of the two screens
  161.             CicloPal(pal);            // Rotate the palette
  162.         }
  163.         for (a=(NUM-1)*64000L;( (a>1280)&&(!kbhit()) );a-=320){
  164.             Pl2Pl(First_addr+a,MCGA_off,64000L);    // Show a part of the two screens
  165.             CicloPal(pal);            // Rotate the palette
  166.         }
  167.     }
  168.  
  169.     // And leave
  170.     QuitVideo();                      // Quit video mode
  171.     getch();                          // Clear keyboard buffer
  172.  
  173.     // Close openned mem. before living
  174.     CloseMem();
  175.  
  176.     // Leave QFM before termination
  177.     LeavePL();
  178. }